home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / MM2_DEV / S / DEMO / ASMDEMO.M < prev    next >
Encoding:
Text File  |  1990-05-03  |  6.1 KB  |  223 lines
  1. MODULE ASMDemo; (*$ E MOS *)
  2.  
  3.   (*
  4.    *  Dieses Modul zeigt, wie man Systemfunktionen in Assembler
  5.    *  aufruft:
  6.    *
  7.    *       1. GEMDOS function call   trap #1
  8.    *       2. BIOS calls             trap #13
  9.    *
  10.    *  Geschrieben von Andreas Pauletti 24.05.1988,
  11.    *  Verifikation von Thomas Tempelmann, 05.07.1988.
  12.    *
  13.    *  Literaturverweis: 'ATARI ST Profibuch' 2.Auflage Sybex-Verlag
  14.    *)
  15.  
  16. FROM SYSTEM IMPORT ASSEMBLER;
  17.  
  18. CONST
  19.     maxChar = 35;
  20. TYPE
  21.     String = ARRAY[0..maxChar] OF CHAR;
  22. VAR
  23.     c: CHAR;
  24.     str0, str1: String;
  25.  
  26. PROCEDURE Conout (c : CHAR);  (* BIOS routine *)
  27.   (*
  28.    * gibt einen einzelnen Buchstaben mittel BIOS Funktion #3 aus
  29.    *)
  30.   (*$L-*)
  31.   BEGIN
  32.     ASSEMBLER
  33.         SUBQ.L  #1,A3         ; parameter stack korroigieren
  34.         MOVE.B  -(A3),D0      ; auszugebender Char in D0
  35.         MOVE    D0,-(A7)      ; D0 auf den CPU-Stack
  36.         MOVE    #2,-(A7)      ; Ausgabe device auf STACK
  37.         MOVE    #3,-(A7)      ; Funktionsnummer auf STACK
  38.         TRAP    #13           ; BIOS Aufruf
  39.         ADDQ.L  #6,A7         ; CPU Stack wieder herstellen
  40.     END(* asm *)
  41.   END Conout;
  42.   (*$L=*)
  43.  
  44. PROCEDURE WriteLn;
  45.   (*
  46.    * spricht für sich !
  47.    *)
  48.   BEGIN
  49.     Conout(CHR(13));
  50.     Conout(CHR(10))
  51.   END WriteLn;
  52.  
  53.  
  54. PROCEDURE PrintLine (VAR str: ARRAY OF CHAR);
  55.   (*
  56.    *  Gibt String str mittel GEMDOS Funktion Cconws (=#9) aus.
  57.    *  Der String muß mit einem Null-Zeichen abgeschlossen sein!
  58.    *)
  59.   BEGIN
  60.     ASSEMBLER
  61.        MOVE.L  str(A6),-(SP)   ; Adresse von 'str' auf Stack
  62.        MOVE.W  #9, -(SP)       ; Funktionsnummer auf STACK
  63.        TRAP    #1              ; GEMDOS Aufruf
  64.        ADDQ.L  #6,A7           ; CPU Stack wieder herstellen
  65.     END
  66.   END PrintLine;
  67.  
  68. PROCEDURE ReadString (VAR s: ARRAY OF CHAR);
  69.   (*
  70.    * liest einen String von der Tastatur ein und zeigt die Eingabe auf
  71.    * dem Bildschirm laufend an.
  72.    * (verwendet GEMDOS-Funktion 10: 'conrs')
  73.    *)
  74.   BEGIN
  75.     ASSEMBLER
  76.         ; zuerst muß in s[0] die Anzahl der max. einzulesenden Zeichen
  77.         ; gespeichert werden. Dies sind die Anzahl der Zeichen des
  78.         ; übergebenen Strings minus Zwei, bzw. der HIGH-Wert minus Eins:
  79.         MOVE.L  s(A6),A0       ; Adr. des Strings
  80.         MOVE.W  s+4(A6),D0     ; HIGH-Wert (immer 4 Byte darüber)
  81.         SUBQ    #1,D0
  82.         MOVE.B  D0,(A0)        ; s[0] setzen
  83.         MOVE.L  A0,-(SP)       ; Adresse von 'str' auf Stack
  84.         MOVE.W  #$0A, -(SP)    ; Funktionsnummer auf STACK
  85.         TRAP    #1             ; GEMDOS Aufruf
  86.         ADDQ.L  #6,SP          ; CPU Stack wieder herstellen
  87.     END
  88.   END ReadString;
  89.  
  90. PROCEDURE WaitForKey (VAR ch : CHAR);
  91.   VAR str: ARRAY[0..79] OF CHAR;
  92.       i: CARDINAL;
  93.   BEGIN
  94.     FOR i:= 0 TO 9 DO
  95.       WriteLn
  96.     END;
  97.     str:= '     [Space] Abbruch  ...   wiederholen beliebige Taste drücken';
  98.     PrintLine(str);
  99.     ASSEMBLER
  100.         MOVE.W #8,-(SP)       ; load function #
  101.         TRAP   #1             ; execute GEMDOS trap
  102.         ADDQ.L #2,SP          ; adjust stack
  103.         MOVE.L ch(A6),A0      ; move address of ch to A0
  104.         MOVE.B D0,(A0)        ; D0 containes in the 1 byte the returned
  105.                               ; ascii value
  106.     END(* asm *)
  107.   END WaitForKey;
  108.  
  109. PROCEDURE ClrScr;
  110.   (*
  111.    * löscht den gesamten Bildschirm über ESC Sequenz
  112.    *)
  113.   BEGIN
  114.     ASSEMBLER
  115.            PEA     ff(PC)       ; push address of string to the stack
  116.            MOVE    #9,-(SP)     ; load function #
  117.            TRAP    #1           ; execute GEMDOS trap
  118.            ADDQ.L  #6,SP        ; adjust stack
  119.            BRA     cont
  120.     ff     DC.B    27,'E',13,0
  121.     cont
  122.     END(* asm *)
  123.   END ClrScr;
  124.  
  125.  
  126. PROCEDURE WriteLnChar (c: CHAR; k: CARDINAL; newLine: BOOLEAN);
  127.   (*
  128.    * Prozedur, die den Buchstaben 'c' k-mal auf den Bildschirm schreibt
  129.    *)
  130.  
  131.   PROCEDURE ConOut (c: CHAR);  (* GEMDOS routine *)
  132.     (*
  133.      * gibt einen einzelnen Buchstaben mittel GEMDOS Funktion #2 aus
  134.      *)
  135.     (*$L-*)
  136.     BEGIN
  137.       ASSEMBLER
  138.           SUBQ.L #1,A3          ; adjust parameter stack
  139.           MOVE.B -(A3),D0       ; move c from parameter stack to D0
  140.           MOVE.W D0,-(SP)       ; now move it to the stack
  141.           MOVE.W #2,-(SP)       ; call GEMDOS function #2
  142.           TRAP   #1
  143.           ADDQ.L #4,SP          ; adjust stack
  144.       END(* asm *)
  145.     END ConOut;
  146.     (*$L=*)
  147.  
  148.   VAR
  149.      i: CARDINAL;
  150.   BEGIN
  151.     FOR i:= 1 TO k DO
  152.       ConOut(c)
  153.     END;
  154.     IF newLine THEN
  155.       WriteLn
  156.     END
  157.   END WriteLnChar;
  158.  
  159. PROCEDURE DoTitle;
  160.   CONST
  161.       text1 ='Demoprogramm zu MEGAMAX MODULA-2';
  162.       text2 ='---------------------------------';
  163.       text3 ='Eingabe und Ausgabe in Assembler';
  164.       blanks = 23;
  165.   VAR
  166.       t: String;
  167.   BEGIN
  168.     WriteLn; WriteLn;
  169.     WriteLnChar(' ', blanks, FALSE);
  170.     t:= text1;
  171.     PrintLine(t); WriteLn;
  172.     WriteLnChar(' ', blanks, FALSE);
  173.     t:= text2;
  174.     PrintLine(t); WriteLn;
  175.     WriteLn;
  176.     WriteLnChar(' ', blanks, FALSE);
  177.     t:= text3;
  178.     PrintLine(t); WriteLn; WriteLn
  179.   END DoTitle;
  180.  
  181. PROCEDURE AdjustString (VAR s: ARRAY OF CHAR);
  182.   (*
  183.    * Prozedur, die zur Umrechnung des Strings dient
  184.    * InputString hat Format : s[1] enthält die Anzahl Buchstaben
  185.    *                          die der String enthält
  186.    *                          eigentliche Daten beginnen ab s[2]
  187.    * OutputString normaler C-Konventions String mit null Byte am Schluss
  188.    *)
  189.   VAR
  190.       i: CARDINAL;
  191.       k: CARDINAL;
  192.   BEGIN
  193.     i:= 2;
  194.     k:= ORD(s[1]);
  195.     WHILE k > 0 DO
  196.       s[i-2]:= s[i];
  197.       INC(i);
  198.       DEC(k)
  199.     END(* while *);
  200.     s[i-2]:= CHR(0)
  201.   END AdjustString;
  202.  
  203.  
  204. BEGIN
  205.   REPEAT
  206.     ClrScr;
  207.     DoTitle;
  208.     WriteLnChar(' ', 2, FALSE);
  209.     WriteLnChar('-', 76, TRUE); WriteLn;
  210.     str0:= '  Geben Sie einen String ein     : ';
  211.     PrintLine(str0);
  212.     ReadString(str1);
  213.     WriteLn; WriteLn;
  214.     WriteLnChar(' ', 2,FALSE);
  215.     WriteLnChar('-', 76, TRUE); WriteLn;
  216.     str0:= '  Der eingegebene String lautete : ';
  217.     PrintLine(str0);
  218.     AdjustString(str1);
  219.     PrintLine(str1);
  220.     WaitForKey(c)
  221.   UNTIL c = ' '
  222. END ASMDemo.
  223.